home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_xfig.idb / usr / freeware / src / xfig / transfig.3.1.2 / fig2dev / bound.c.z / bound.c
Encoding:
C/C++ Source or Header  |  1997-09-09  |  14.4 KB  |  504 lines
  1. /*
  2.  * TransFig: Facility for Translating Fig code
  3.  * Copyright (c) 1985 Supoj Sutantavibul
  4.  * Copyright (c) 1991 Micah Beck
  5.  *
  6.  * THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  7.  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  8.  * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  9.  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  10.  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  11.  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  12.  * PERFORMANCE OF THIS SOFTWARE.
  13.  *
  14.  * The X Consortium, and any party obtaining a copy of these files from
  15.  * the X Consortium, directly or indirectly, is granted, free of charge, a
  16.  * full and unrestricted irrevocable, world-wide, paid up, royalty-free,
  17.  * nonexclusive right and license to deal in this software and
  18.  * documentation files (the "Software"), including without limitation the
  19.  * rights to use, copy, modify, merge, publish, distribute, sublicense,
  20.  * and/or sell copies of the Software, and to permit persons who receive
  21.  * copies from any such party to do so, with the only requirement being
  22.  * that this copyright notice remain intact.  This license includes without
  23.  * limitation a license to do the foregoing actions under any patents of
  24.  * the party supplying this software to the X Consortium.
  25.  */
  26.  
  27. #include <stdio.h>
  28. #include <math.h>
  29. #include "pi.h"
  30. #include "fig2dev.h"
  31. #include "object.h"
  32.  
  33. #define        Ninety_deg        M_PI_2
  34. #define        One_eighty_deg        M_PI
  35. #define        Two_seventy_deg        (M_PI + M_PI_2)
  36. #define        Three_sixty_deg        (M_PI + M_PI)
  37. #define        half(z1 ,z2)        ((z1+z2)/2.0)
  38. #define        max(a, b)        (((a) > (b)) ? (a) : (b))
  39. #define        min(a, b)        (((a) < (b)) ? (a) : (b))
  40.  
  41. arc_bound(arc, xmin, ymin, xmax, ymax)
  42. F_arc    *arc;
  43. int    *xmin, *ymin, *xmax, *ymax;
  44. {
  45.     double    alpha, beta;
  46.     double    dx, dy, radius;
  47.     int    bx, by, sx, sy;
  48.  
  49.     dx = arc->point[0].x - arc->center.x;
  50.     dy = arc->center.y - arc->point[0].y;
  51.     alpha = atan2(dy, dx);
  52.     if (alpha < 0.0) alpha += Three_sixty_deg;
  53.     /* compute_angle returns value between 0 to 2PI */
  54.     
  55.     radius = hypot(dx, dy);
  56.  
  57.     dx = arc->point[2].x - arc->center.x;
  58.     dy = arc->center.y - arc->point[2].y;
  59.     beta = atan2(dy, dx);
  60.     if (beta < 0.0) beta += Three_sixty_deg;
  61.  
  62.     bx = max(arc->point[0].x, arc->point[1].x);
  63.     bx = max(arc->point[2].x, bx);
  64.     by = max(arc->point[0].y, arc->point[1].y);
  65.     by = max(arc->point[2].y, by);
  66.     sx = min(arc->point[0].x, arc->point[1].x);
  67.     sx = min(arc->point[2].x, sx);
  68.     sy = min(arc->point[0].y, arc->point[1].y);
  69.     sy = min(arc->point[2].y, sy);
  70.  
  71.     if (arc->direction == 1) { /* counter clockwise */
  72.         if (alpha > beta) {
  73.         if (alpha <= 0 || 0 <= beta)
  74.             bx = (int)(arc->center.x + radius + 1.0);
  75.         if (alpha <= Ninety_deg || Ninety_deg <= beta)
  76.             sy = (int)(arc->center.y - radius - 1.0);
  77.         if (alpha <= One_eighty_deg || One_eighty_deg <= beta)
  78.             sx = (int)(arc->center.x - radius - 1.0);
  79.         if (alpha <= Two_seventy_deg || Two_seventy_deg <= beta)
  80.             by = (int)(arc->center.y + radius + 1.0);
  81.         }
  82.         else {
  83.         if (0 <= beta && alpha <= 0)
  84.             bx = (int)(arc->center.x + radius + 1.0);
  85.         if (Ninety_deg <= beta && alpha <= Ninety_deg)
  86.             sy = (int)(arc->center.y - radius - 1.0);
  87.         if (One_eighty_deg <= beta && alpha <= One_eighty_deg)
  88.             sx = (int)(arc->center.x - radius - 1.0);
  89.         if (Two_seventy_deg <= beta && alpha <= Two_seventy_deg)
  90.             by = (int)(arc->center.y + radius + 1.0);
  91.         }
  92.         }
  93.     else {    /* clockwise    */
  94.         if (alpha > beta) {
  95.         if (beta <= 0 && 0 <= alpha)
  96.             bx = (int)(arc->center.x + radius + 1.0);
  97.         if (beta <= Ninety_deg && Ninety_deg <= alpha)
  98.             sy = (int)(arc->center.y - radius - 1.0);
  99.         if (beta <= One_eighty_deg && One_eighty_deg <= alpha)
  100.             sx = (int)(arc->center.x - radius - 1.0);
  101.         if (beta <= Two_seventy_deg && Two_seventy_deg <= alpha)
  102.             by = (int)(arc->center.y + radius + 1.0);
  103.         }
  104.         else {
  105.         if (0 <= alpha || beta <= 0)
  106.             bx = (int)(arc->center.x + radius + 1.0);
  107.         if (Ninety_deg <= alpha || beta <= Ninety_deg)
  108.             sy = (int)(arc->center.y - radius - 1.0);
  109.         if (One_eighty_deg <= alpha || beta <= One_eighty_deg)
  110.             sx = (int)(arc->center.x - radius - 1.0);
  111.         if (Two_seventy_deg <= alpha || beta <= Two_seventy_deg)
  112.             by = (int)(arc->center.y + radius + 1.0);
  113.         }
  114.         }
  115.     *xmax = bx; *ymax = by;
  116.     *xmin = sx; *ymin = sy;
  117.     }
  118.  
  119. compound_bound(compound, xmin, ymin, xmax, ymax, include)
  120. F_compound    *compound;
  121. int        *xmin, *ymin, *xmax, *ymax;
  122. int        include;
  123. {
  124.     F_arc        *a;
  125.     F_ellipse    *e;
  126.     F_compound    *c;
  127.     F_spline    *s;
  128.     F_line        *l;
  129.     F_text        *t;
  130.     int        bx, by, sx, sy, first = 1;
  131.     int        llx, lly, urx, ury;
  132.     int            half_wd;
  133.  
  134.     while(compound != NULL) {
  135.     for (a = compound->arcs; a != NULL; a = a->next) {
  136.         arc_bound(a, &sx, &sy, &bx, &by);
  137.             half_wd = (a->thickness + 1) / 2;
  138.         if (first) {
  139.         first = 0;
  140.         llx = sx - half_wd; lly = sy - half_wd;
  141.         urx = bx + half_wd; ury = by + half_wd;
  142.         }
  143.         else {
  144.         llx = min(llx, sx - half_wd); lly = min(lly, sy - half_wd);
  145.         urx = max(urx, bx + half_wd); ury = max(ury, by + half_wd);
  146.         }
  147.         }
  148.  
  149.     if (compound->compounds) {
  150.         compound_bound(compound->compounds, &sx, &sy, &bx, &by, include);
  151.         if (first) {
  152.         first = 0;
  153.         llx = sx; lly = sy;
  154.         urx = bx; ury = by;
  155.         }
  156.         else {
  157.         llx = min(llx, sx); lly = min(lly, sy);
  158.         urx = max(urx, bx); ury = max(ury, by);
  159.         }
  160.         }
  161.  
  162.     for (e = compound->ellipses; e != NULL; e = e->next) {
  163.         ellipse_bound(e, &sx, &sy, &bx, &by);
  164.         if (first) {
  165.         first = 0;
  166.         llx = sx; lly = sy;
  167.         urx = bx; ury = by;
  168.         }
  169.         else {
  170.         llx = min(llx, sx); lly = min(lly, sy);
  171.         urx = max(urx, bx); ury = max(ury, by);
  172.         }
  173.         }
  174.  
  175.     for (l = compound->lines; l != NULL; l = l->next) {
  176.         line_bound(l, &sx, &sy, &bx, &by);
  177.             half_wd = ceil((double)(l->thickness+1) / sqrt(2.0)); 
  178.             /* leave space for corners, better approach needs much more math! */
  179.         if (first) {
  180.         first = 0;
  181.         llx = sx - half_wd; lly = sy - half_wd;
  182.         urx = bx + half_wd; ury = by + half_wd;
  183.         }
  184.         else {
  185.         llx = min(llx, sx - half_wd); lly = min(lly, sy - half_wd);
  186.         urx = max(urx, bx + half_wd); ury = max(ury, by + half_wd);
  187.         }
  188.         }
  189.  
  190.     for (s = compound->splines; s != NULL; s = s->next) {
  191.         spline_bound(s, &sx, &sy, &bx, &by);
  192.             half_wd = (s->thickness+1) / 2;
  193.         if (first) {
  194.         first = 0;
  195.         llx = sx - half_wd; lly = sy - half_wd;
  196.         urx = bx + half_wd; ury = by + half_wd;
  197.         }
  198.         else {
  199.         llx = min(llx, sx - half_wd); lly = min(lly, sy - half_wd);
  200.         urx = max(urx, bx + half_wd); ury = max(ury, by + half_wd);
  201.         }
  202.         }
  203.  
  204.     for (t = compound->texts; t != NULL; t = t->next) {
  205.         text_bound(t, &sx, &sy, &bx, &by, include);
  206.         if (first) {
  207.         first = 0;
  208.         llx = sx; lly = sy;
  209.         urx = bx; ury = by;
  210.         }
  211.         else {
  212.         llx = min(llx, sx); lly = min(lly, sy);
  213.         urx = max(urx, bx); ury = max(ury, by);
  214.         }
  215.         }
  216.         compound = compound->next;
  217.     }
  218.  
  219.     *xmin = llx; *ymin = lly;
  220.     *xmax = urx; *ymax = ury;
  221. }
  222.  
  223. ellipse_bound(e, xmin, ymin, xmax, ymax)
  224. F_ellipse    *e;
  225. int        *xmin, *ymin, *xmax, *ymax;
  226. { 
  227.     /* stolen from xfig-2.1.8 max2 from xfig == max here*/
  228.  
  229.     int        half_wd;
  230.     double        c1, c2, c3, c4, c5, c6, v1, cphi, sphi, cphisqr, sphisqr;
  231.     double        xleft, xright, d, asqr, bsqr;
  232.     int        yymax, yy=0;
  233.     float        xcen, ycen, a, b; 
  234.  
  235.     xcen = e->center.x;
  236.     ycen = e->center.y;
  237.     a = e->radiuses.x;
  238.     b = e->radiuses.y;
  239.     if (a==0 || b==0) {
  240.         *xmin = *xmax = xcen;
  241.         *ymin = *ymax = ycen;
  242.         return;
  243.     }
  244.  
  245.     cphi = cos((double)e->angle);
  246.     sphi = sin((double)e->angle);
  247.     cphisqr = cphi*cphi;
  248.     sphisqr = sphi*sphi;
  249.     asqr = a*a;
  250.     bsqr = b*b;
  251.     
  252.     c1 = (cphisqr/asqr)+(sphisqr/bsqr);
  253.     c2 = ((cphi*sphi/asqr)-(cphi*sphi/bsqr))/c1;
  254.     c3 = (bsqr*cphisqr) + (asqr*sphisqr);
  255.     yymax = sqrt(c3);
  256.     c4 = a*b/c3;
  257.     c5 = 0;
  258.     v1 = c4*c4;
  259.     c6 = 2*v1;
  260.     c3 = c3*v1-v1;
  261.     /* odd first points */
  262.     *xmin = *ymin =  100000;
  263.     *xmax = *ymax = -100000;
  264.     if (yymax % 2) {
  265.         d = sqrt(c3);
  266.         *xmin = min(*xmin,xcen-ceil(d));
  267.         *xmax = max(*xmax,xcen+ceil(d));
  268.         *ymin = min(*ymin,ycen);
  269.         *ymax = max(*ymax,ycen);
  270.         c5 = c2;
  271.         yy=1;
  272.     }
  273.     while (c3>=0) {
  274.         d = sqrt(c3);
  275.         xleft = c5-d;
  276.         xright = c5+d;                        
  277.         *xmin = min(*xmin,xcen+floor(xleft));
  278.         *xmax = max(*xmax,xcen+ceil(xleft));
  279.         *ymax = max(*ymax,ycen+yy);
  280.         *xmin = min(*xmin,xcen+floor(xright));
  281.         *xmax = max(*xmax,xcen+ceil(xright));
  282.         *ymax = max(*ymax,ycen+yy);
  283.         *xmin = min(*xmin,xcen-ceil(xright));
  284.         *xmax = max(*xmax,xcen-floor(xright));
  285.         *ymin = min(*ymin,ycen-yy);
  286.         *xmin = min(*xmin,xcen-ceil(xleft));
  287.         *xmax = max(*xmax,xcen-floor(xleft));
  288.         *ymin = min(*ymin,ycen-yy);
  289.         c5+=c2;
  290.         v1+=c6;
  291.         c3-=v1;
  292.         yy=yy+1;
  293.     }
  294.     /* for simplicity, just add half the line thickness to xmax and ymax
  295.        and subtract half from xmin and ymin */
  296.     half_wd = (e->thickness+1)/2; /*correct for integer division */
  297.     *xmax += half_wd;
  298.     *ymax += half_wd;
  299.     *xmin -= half_wd;
  300.     *ymin -= half_wd;
  301.     }
  302.  
  303. line_bound(l, xmin, ymin, xmax, ymax)
  304. F_line    *l;
  305. int    *xmin, *ymin, *xmax, *ymax;
  306. {
  307.     points_bound(l->points, xmin, ymin, xmax, ymax);
  308.     }
  309.  
  310. spline_bound(s, xmin, ymin, xmax, ymax)
  311. F_spline    *s;
  312. int        *xmin, *ymin, *xmax, *ymax;
  313. {
  314.     if (int_spline(s)) {
  315.         int_spline_bound(s, xmin, ymin, xmax, ymax);
  316.         }
  317.     else {
  318.         normal_spline_bound(s, xmin, ymin, xmax, ymax);
  319.         }
  320.     }
  321.  
  322. int_spline_bound(s, xmin, ymin, xmax, ymax)
  323. F_spline    *s;
  324. int        *xmin, *ymin, *xmax, *ymax;
  325. {
  326.     F_point        *p1, *p2;
  327.     F_control    *cp1, *cp2;
  328.     double        x0, y0, x1, y1, x2, y2, x3, y3, sx1, sy1, sx2, sy2;
  329.     double        tx, ty, tx1, ty1, tx2, ty2;
  330.     double        sx, sy, bx, by;
  331.  
  332.     p1 = s->points;
  333.     sx = bx = p1->x;
  334.     sy = by = p1->y;
  335.     cp1 = s->controls;
  336.     for (p2 = p1->next, cp2 = cp1->next; p2 != NULL;
  337.         p1 = p2, cp1 = cp2, p2 = p2->next, cp2 = cp2->next) {
  338.         x0 = p1->x; y0 = p1->y;
  339.         x1 = cp1->rx; y1 = cp1->ry;
  340.         x2 = cp2->lx; y2 = cp2->ly;
  341.         x3 = p2->x; y3 = p2->y;
  342.         tx = half(x1, x2); ty = half(y1, y2);
  343.         sx1 = half(x0, x1); sy1 = half(y0, y1);
  344.         sx2 = half(sx1, tx); sy2 = half(sy1, ty);
  345.         tx2 = half(x2, x3); ty2 = half(y2, y3);
  346.         tx1 = half(tx2, tx); ty1 = half(ty2, ty);
  347.  
  348.         sx = min(x0, sx); sy = min(y0, sy);
  349.         sx = min(sx1, sx); sy = min(sy1, sy);
  350.         sx = min(sx2, sx); sy = min(sy2, sy);
  351.         sx = min(tx1, sx); sy = min(ty1, sy);
  352.         sx = min(tx2, sx); sy = min(ty2, sy);
  353.         sx = min(x3, sx); sy = min(y3, sy);
  354.  
  355.         bx = max(x0, bx); by = max(y0, by);
  356.         bx = max(sx1, bx); by = max(sy1, by);
  357.         bx = max(sx2, bx); by = max(sy2, by);
  358.         bx = max(tx1, bx); by = max(ty1, by);
  359.         bx = max(tx2, bx); by = max(ty2, by);
  360.         bx = max(x3, bx); by = max(y3, by);
  361.         }
  362.     *xmin = round(sx);
  363.     *ymin = round(sy);
  364.     *xmax = round(bx);
  365.     *ymax = round(by);
  366.     }
  367.  
  368. normal_spline_bound(s, xmin, ymin, xmax, ymax)
  369. F_spline    *s;
  370. int        *xmin, *ymin, *xmax, *ymax;
  371. {
  372.     F_point    *p;
  373.     double    cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
  374.     double    x1, y1, x2, y2, sx, sy, bx, by;
  375.     double    px, py, qx, qy;
  376.  
  377.     p = s->points;
  378.     x1 = p->x;  y1 = p->y;
  379.     p = p->next;
  380.     x2 = p->x;  y2 = p->y;
  381.     cx1 = (x1 + x2) / 2.0;   cy1 = (y1 + y2) / 2.0;
  382.     cx2 = (cx1 + x2) / 2.0;  cy2 = (cy1 + y2) / 2.0;
  383.     if (closed_spline(s)) {
  384.         x1 = (cx1 + x1) / 2.0;
  385.         y1 = (cy1 + y1) / 2.0;
  386.         }
  387.     sx = min(x1, cx2); sy = min(y1, cy2);
  388.     bx = max(x1, cx2); by = max(y1, cy2);
  389.  
  390.     for (p = p->next; p != NULL; p = p->next) {
  391.         x1 = x2;  y1 = y2;
  392.         x2 = p->x;  y2 = p->y;
  393.         cx4 = (x1 + x2) / 2.0; cy4 = (y1 + y2) / 2.0;
  394.         cx3 = (x1 + cx4) / 2.0; cy3 = (y1 + cy4) / 2.0;
  395.         cx2 = (cx4 + x2) / 2.0;  cy2 = (cy4 + y2) / 2.0;
  396.  
  397.         px = min(cx2, cx3); py = min(cy2, cy3);
  398.         qx = max(cx2, cx3); qy = max(cy2, cy3);
  399.  
  400.         sx = min(sx, px); sy = min(sy, py);
  401.         bx = max(bx, qx); by = max(by, qy);
  402.         }
  403.     if (closed_spline(s)) {
  404.         *xmin = floor(sx );
  405.         *ymin = floor(sy );
  406.         *xmax = ceil (bx );
  407.         *ymax = ceil (by );
  408.         }
  409.     else {
  410.         *xmin = floor(min(sx, x2) );
  411.         *ymin = floor(min(sy, y2) );
  412.         *xmax = ceil (max(bx, x2) );
  413.         *ymax = ceil (max(by, y2) );
  414.         }
  415.     }
  416.  
  417. double rot_x(x,y,angle) 
  418. double x,y,angle;
  419. {
  420.     return(x*cos(-angle)-y*sin(-angle));
  421. }
  422.  
  423. double rot_y(x,y,angle)
  424. double x,y,angle;
  425. {
  426.  return(x*sin(-angle)+y*cos(-angle));
  427. }
  428.  
  429.  
  430. text_bound(t, xmin, ymin, xmax, ymax, include)
  431. F_text    *t;
  432. int    *xmin, *ymin, *xmax, *ymax;
  433. int    include;
  434. {
  435.     double dx1, dx2, dx3, dx4, dy1, dy2, dy3, dy4;
  436.     /* characters have some extent downside */
  437.     if (t->type == T_CENTER_JUSTIFIED) {
  438.         dx1 = (t->length/1.95);     dy1 =  0.2*t->height;
  439.         dx2 = -(t->length/1.95);    dy2 =  0.2*t->height;
  440.         dx3 = (t->length/1.95);     dy3 = -0.8*t->height;
  441.         dx4 = -(t->length/1.95);    dy4 = -0.8*t->height;
  442.     } else if (t->type == T_RIGHT_JUSTIFIED) {
  443.         dx1 = 0.0;                      dy1 =  0.2*t->height;
  444.         dx2 = -t->length*1.0256;        dy2 =  0.2*t->height;
  445.         dx3 = 0.0;                      dy3 = -0.8*t->height;
  446.         dx4 = -t->length*1.0256;        dy4 = -0.8*t->height;
  447.     } else {
  448.         dx1 = (include ? t->length*1.0256 : 0); dy1 =  0.2*t->height;
  449.         dx2 = 0.0;                              dy2 =  0.2*t->height;
  450.         dx3 = (include ? t->length*1.0256 : 0); dy3 = -0.8*t->height;
  451.         dx4 = 0.0;                              dy4 = -0.8*t->height;
  452.     }
  453.     *xmax= t->base_x +
  454.            max( max( rot_x(dx1,dy1,t->angle), rot_x(dx2,dy2,t->angle) ), 
  455.             max( rot_x(dx3,dy3,t->angle), rot_x(dx4,dy4,t->angle) ) );
  456.     *ymax= t->base_y + 
  457.            max( max( rot_y(dx1,dy1,t->angle), rot_y(dx2,dy2,t->angle) ), 
  458.             max( rot_y(dx3,dy3,t->angle), rot_y(dx4,dy4,t->angle) ) );
  459.  
  460.     *xmin= t->base_x + 
  461.            min( min( rot_x(dx1,dy1,t->angle), rot_x(dx2,dy2,t->angle) ), 
  462.             min( rot_x(dx3,dy3,t->angle), rot_x(dx4,dy4,t->angle) ) );
  463.     *ymin= t->base_y + 
  464.            min( min( rot_y(dx1,dy1,t->angle), rot_y(dx2,dy2,t->angle) ), 
  465.             min( rot_y(dx3,dy3,t->angle), rot_y(dx4,dy4,t->angle) ) );
  466.     }
  467.  
  468. points_bound(points, xmin, ymin, xmax, ymax)
  469. F_point    *points;
  470. int    *xmin, *ymin, *xmax, *ymax;
  471. {
  472.     int    bx, by, sx, sy;
  473.     F_point    *p;
  474.  
  475.     bx = sx = points->x; by = sy = points->y;
  476.     for (p = points->next; p != NULL; p = p->next) {
  477.         sx = min(sx, p->x); sy = min(sy, p->y);
  478.         bx = max(bx, p->x); by = max(by, p->y);
  479.         }
  480.     *xmin = sx; *ymin = sy;
  481.     *xmax = bx; *ymax = by;
  482.     }
  483.  
  484. control_points_bound(cps, xmin, ymin, xmax, ymax)
  485. F_control    *cps;
  486. int        *xmin, *ymin, *xmax, *ymax;
  487. {
  488.     F_control    *c;
  489.     double        bx, by, sx, sy;
  490.  
  491.     bx = sx = cps->lx;
  492.     by = sy = cps->ly;
  493.     sx = min(sx, cps->rx); sy = min(sy, cps->ry);
  494.     bx = max(bx, cps->rx); by = max(by, cps->ry);
  495.     for (c = cps->next; c != NULL; c = c->next) {
  496.         sx = min(sx, c->lx); sy = min(sy, c->ly);
  497.         bx = max(bx, c->lx); by = max(by, c->ly);
  498.         sx = min(sx, c->rx); sy = min(sy, c->ry);
  499.         bx = max(bx, c->rx); by = max(by, c->ry);
  500.         }
  501.     *xmin = round(sx); *ymin = round(sy);
  502.     *xmax = round(bx); *ymax = round(by);
  503.     }
  504.